use crate::error::{Result, PipitError};
use crate::vm::Value;


// RV32I指令集定义
#[derive(Debug, Clone)]
pub enum RV32IInstruction {
    // R类型指令
    ADD(u8, u8, u8),    // rd, rs1, rs2
    SUB(u8, u8, u8),    // rd, rs1, rs2
    AND(u8, u8, u8),    // rd, rs1, rs2
    OR(u8, u8, u8),     // rd, rs1, rs2
    XOR(u8, u8, u8),    // rd, rs1, rs2
    SLL(u8, u8, u8),    // rd, rs1, rs2
    SRL(u8, u8, u8),    // rd, rs1, rs2
    SRA(u8, u8, u8),    // rd, rs1, rs2
    SLT(u8, u8, u8),    // rd, rs1, rs2
    SLTU(u8, u8, u8),   // rd, rs1, rs2
    // I类型指令
    ADDI(u8, u8, i32),  // rd, rs1, imm
    SLTI(u8, u8, i32),  // rd, rs1, imm
    SLTIU(u8, u8, i32), // rd, rs1, imm
    XORI(u8, u8, i32),  // rd, rs1, imm
    ORI(u8, u8, i32),   // rd, rs1, imm
    ANDI(u8, u8, i32),  // rd, rs1, imm
    SLLI(u8, u8, i32),  // rd, rs1, imm
    SRLI(u8, u8, i32),  // rd, rs1, imm
    SRAI(u8, u8, i32),  // rd, rs1, imm
    // 内存访问指令
    LW(u8, u8, i32),    // rd, rs1, imm
    LH(u8, u8, i32),    // rd, rs1, imm
    LB(u8, u8, i32),    // rd, rs1, imm
    LHU(u8, u8, i32),   // rd, rs1, imm
    LBU(u8, u8, i32),   // rd, rs1, imm
    SW(u8, u8, i32),    // rs2, rs1, imm
    SH(u8, u8, i32),    // rs2, rs1, imm
    SB(u8, u8, i32),    // rs2, rs1, imm
    // 分支指令
    BEQ(u8, u8, i32),   // rs1, rs2, imm
    BNE(u8, u8, i32),   // rs1, rs2, imm
    BLT(u8, u8, i32),   // rs1, rs2, imm
    BGE(u8, u8, i32),   // rs1, rs2, imm
    BLTU(u8, u8, i32),  // rs1, rs2, imm
    BGEU(u8, u8, i32),  // rs1, rs2, imm
    // J类型指令
    JAL(u8, i32),       // rd, imm
    JALR(u8, u8, i32),  // rd, rs1, imm
    // U类型指令
    LUI(u8, u32),       // rd, imm
    AUIPC(u8, u32),     // rd, imm
    // 其他指令
    FENCE,              // 内存屏障
    FENCEI,             // 指令屏障
    ECALL,              // 环境调用
    EBREAK,             // 环境断点
    // 伪指令
    NOP,                // 空操作
    MV(u8, u8),         // 寄存器移动
    LI(u8, i32),        // 加载立即数
    HALT,               // 停机指令
    // 调试和性能测量指令
    PrintReg(u8),       // 打印寄存器值
    TimerStart,         // 启动计时器
    TimerStop,          // 停止计时器
    TimerRead(u8),      // 读取计时器值到寄存器
}

// 五级流水线寄存器结构
#[derive(Debug, Clone)]
pub struct PipelineRegister {
    pub instruction: Option<RV32IInstruction>,  // 指令
    pub pc: u32,                              // 程序计数器
    pub rs1_value: Option<Value>,              // 源寄存器1的值
    pub rs2_value: Option<Value>,              // 源寄存器2的值
    pub alu_result: Option<u32>,               // ALU运算结果
    pub memory_data: Option<Value>,            // 内存数据
}

impl PipelineRegister {
    // 创建新的流水线寄存器
    pub fn new() -> Self {
        PipelineRegister {
            instruction: None,
            pc: 0,
            rs1_value: None,
            rs2_value: None,
            alu_result: None,
            memory_data: None,
        }
    }
    
    // 清空流水线寄存器
    pub fn clear(&mut self) {
        self.instruction = None;
        self.pc = 0;
        self.rs1_value = None;
        self.rs2_value = None;
        self.alu_result = None;
        self.memory_data = None;
    }
}

// RV32I虚拟机器实现
#[derive(Debug)]
pub struct RV32IVirtualMachine {
    pub registers: [Value; 32],                  // 32个通用寄存器
    pub pc: u32,                                 // 程序计数器
    pub instructions: Vec<RV32IInstruction>,     // 指令存储
    pub pipeline_registers: [PipelineRegister; 4], // 流水线寄存器
    pub pipeline_stall: bool,                    // 流水线暂停标志
    pub branch_taken: bool,                      // 分支成功标志
    pub next_pc: u32,                            // 下一个PC值
    pub memory: Vec<Value>,                      // 内存
    pub stack: Vec<Value>,                       // 栈
    // 是否打印详细调试输出，用于控制运行时 IO，默认 false
    pub verbose: bool,
}

impl RV32IVirtualMachine {
    pub fn new() -> Self {
        RV32IVirtualMachine {
            registers: [const { Value::Integer(0) }; 32],
            pc: 0,
            instructions: Vec::new(),
            pipeline_registers: [(); 4].map(|_| PipelineRegister::new()),
            pipeline_stall: false,
            branch_taken: false,
            next_pc: 0,
            memory: Vec::new(),
            stack: Vec::new(),
            verbose: false,
        }
    }

    /// 设置是否启用详细调试输出
    pub fn set_verbose(&mut self, v: bool) {
        self.verbose = v;
    }
    
    // 加载指令
    pub fn load_instructions(&mut self, instructions: Vec<RV32IInstruction>) {
        self.instructions = instructions;
    }
    
    // 写入寄存器
    pub fn write_register(&mut self, reg: u8, value: Value) {
        if reg != 0 { // x0寄存器始终为0，不可写
            self.registers[reg as usize] = value;
        }
    }
    
    // 读取寄存器
    pub fn read_register(&self, reg: u8) -> &Value {
        if reg == 0 {
            &Value::Integer(0) // x0寄存器始终返回0
        } else {
            &self.registers[reg as usize]
        }
    }
    
    // 写入内存
    pub fn write_memory(&mut self, address: u32, value: Value) -> Result<()> {
        if address as usize >= self.memory.len() {
            // 动态扩展内存
            self.memory.resize((address + 1024) as usize, Value::Integer(0));
        }
        self.memory[address as usize] = value;
        Ok(())
    }
    
    // 读取内存
    pub fn read_memory(&self, address: u32) -> Result<&Value> {
        if address as usize >= self.memory.len() {
            Err(PipitError::RuntimeError("Memory access out of bounds".to_string()))
        } else {
            Ok(&self.memory[address as usize])
        }
    }
    
    // 五级流水线执行
    pub fn execute_pipeline(&mut self) -> Result<()> {
        // 1. 保存当前流水线状态的副本
        let current_pipeline = self.pipeline_registers.clone();
        
        // 2. 执行IF阶段 (取指)
        if ((self.pc / 4) as usize) < self.instructions.len() {
            // 创建一个IF/ID阶段的新副本
            let mut if_id = PipelineRegister::new();
            
            // 从指令存储中获取指令
            let instruction_index = (self.pc / 4) as usize;
            let instruction = &self.instructions[instruction_index];
            
            // 设置IF/ID流水线寄存器
            if_id.instruction = Some(instruction.clone());
            if_id.pc = self.pc;
            
            // 将处理后的结果写回IF/ID阶段
            self.pipeline_registers[0] = if_id;
            
            // 更新PC
            if self.branch_taken {
                self.pc = self.next_pc;
                self.branch_taken = false;
            } else {
                self.pc += 4;
            }
        } else {
            // 如果没有更多指令要取，创建一个NOP指令填充流水线
            let mut if_id = PipelineRegister::new();
            if_id.instruction = Some(RV32IInstruction::NOP);
            if_id.pc = self.pc;
            self.pipeline_registers[0] = if_id;
        }
        
        // 3. 执行ID阶段 (译码)
        // 使用之前保存的IF/ID寄存器状态
        let mut id_ex = PipelineRegister::new();
        if let Some(instruction) = &current_pipeline[0].instruction {
            id_ex.instruction = Some(instruction.clone());
            id_ex.pc = current_pipeline[0].pc;
            
            // 解析指令，获取源寄存器值
            match instruction {
                RV32IInstruction::ADD(_, rs1, rs2) |
                RV32IInstruction::SUB(_, rs1, rs2) |
                RV32IInstruction::AND(_, rs1, rs2) |
                RV32IInstruction::OR(_, rs1, rs2) |
                RV32IInstruction::XOR(_, rs1, rs2) |
                RV32IInstruction::SLL(_, rs1, rs2) |
                RV32IInstruction::SRL(_, rs1, rs2) |
                RV32IInstruction::SRA(_, rs1, rs2) |
                RV32IInstruction::SLT(_, rs1, rs2) |
                RV32IInstruction::SLTU(_, rs1, rs2) => {
                    // 读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone());
                },
                
                RV32IInstruction::LW(_, rs1, _) |
                RV32IInstruction::LH(_, rs1, _) |
                RV32IInstruction::LB(_, rs1, _) |
                RV32IInstruction::LHU(_, rs1, _) |
                RV32IInstruction::LBU(_, rs1, _) => {
                    // 加载指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::SW(rs2, rs1, _) |
                RV32IInstruction::SH(rs2, rs1, _) |
                RV32IInstruction::SB(rs2, rs1, _) => {
                    // 存储指令：读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone()); // SW的rs2是源寄存器
                },
                
                RV32IInstruction::ADDI(_, rs1, _) |
                RV32IInstruction::SLTI(_, rs1, _) |
                RV32IInstruction::SLTIU(_, rs1, _) |
                RV32IInstruction::XORI(_, rs1, _) |
                RV32IInstruction::ORI(_, rs1, _) |
                RV32IInstruction::ANDI(_, rs1, _) |
                RV32IInstruction::SLLI(_, rs1, _) |
                RV32IInstruction::SRLI(_, rs1, _) |
                RV32IInstruction::SRAI(_, rs1, _) => {
                    // 立即数指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::BEQ(rs1, rs2, _) |
                RV32IInstruction::BNE(rs1, rs2, _) |
                RV32IInstruction::BLT(rs1, rs2, _) |
                RV32IInstruction::BGE(rs1, rs2, _) |
                RV32IInstruction::BLTU(rs1, rs2, _) |
                RV32IInstruction::BGEU(rs1, rs2, _) => {
                    // 分支指令：读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone());
                },
                
                RV32IInstruction::JAL(_, _) => {
                    // JAL指令不需要读取寄存器
                },
                
                RV32IInstruction::JALR(_, rs1, _) => {
                    // JALR指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::LUI(_, _) |
                RV32IInstruction::AUIPC(_, _) => {
                    // LUI和AUIPC指令不需要读取寄存器
                },
                
                RV32IInstruction::MV(_, rs1) => {
                    // 寄存器移动：读取源寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                _ => {}
            }
        }
        
        // 4. 执行EX阶段 (执行)
        // 使用当前计算出的ID/EX寄存器状态
        let mut ex_mem = PipelineRegister::new();
        if let Some(instruction) = &id_ex.instruction {
            ex_mem.instruction = Some(instruction.clone());
            ex_mem.pc = id_ex.pc;
            ex_mem.rs1_value = id_ex.rs1_value.clone();
            ex_mem.rs2_value = id_ex.rs2_value.clone();
            
            // 执行ALU操作
            match instruction {
                RV32IInstruction::ADD(_, _, _) => {
                    // 执行加法操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((*a + *b) as u32);
                    }
                },
                RV32IInstruction::SUB(_, _, _) => {
                    // 执行减法操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a - *b) as u32);
                    }
                },
                RV32IInstruction::AND(_, _, _) => {
                    // 执行与操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a & *b) as u32);
                    }
                },
                RV32IInstruction::OR(_, _, _) => {
                    // 执行或操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a | *b) as u32);
                    }
                },
                RV32IInstruction::XOR(_, _, _) => {
                    // 执行异或操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a ^ *b) as u32);
                    }
                },
                RV32IInstruction::SLL(_, _, _) => {
                    // 执行左移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a << (*b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRL(_, _, _) => {
                    // 执行逻辑右移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a as u32 >> (*b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRA(_, _, _) => {
                    // 执行算术右移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a >> (*b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SLT(_, _, _) => {
                    // 执行有符号比较操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some(if *a < *b { 1 } else { 0 });
                    }
                },
                RV32IInstruction::SLTU(_, _, _) => {
                    // 执行无符号比较操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some(if (*a as u32) < (*b as u32) { 1 } else { 0 });
                    }
                },
                RV32IInstruction::ADDI(_, _, imm) => {
                    // 执行加立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::SLTI(_, _, imm) => {
                    // 执行有符号立即数比较操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some(if *a < *imm { 1 } else { 0 });
                    }
                },
                RV32IInstruction::SLTIU(_, _, imm) => {
                    // 执行无符号立即数比较操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some(if (*a as u32) < (*imm as u32) { 1 } else { 0 });
                    }
                },
                RV32IInstruction::XORI(_, _, imm) => {
                    // 执行异或立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a ^ *imm) as u32);
                    }
                },
                RV32IInstruction::ORI(_, _, imm) => {
                    // 执行或立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a | *imm) as u32);
                    }
                },
                RV32IInstruction::ANDI(_, _, imm) => {
                    // 执行与立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a & *imm) as u32);
                    }
                },
                RV32IInstruction::SLLI(_, _, imm) => {
                    // 执行立即数左移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a << (*imm & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRLI(_, _, imm) => {
                    // 执行立即数逻辑右移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {                        
                        ex_mem.alu_result = Some((*a as u32 >> (*imm & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRAI(_, _, imm) => {
                    // 执行立即数算术右移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a >> (*imm & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::LW(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::LH(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::LB(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::LHU(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::LBU(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::SW(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::SH(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::SB(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a + *imm) as u32);
                    }
                },
                RV32IInstruction::LUI(_, imm) => {
                    // LUI指令：将立即数左移12位
                    ex_mem.alu_result = Some(*imm);
                },
                RV32IInstruction::AUIPC(_, imm) => {
                    // AUIPC指令：将立即数左移12位并加上PC
                    ex_mem.alu_result = Some(imm.wrapping_add(ex_mem.pc));
                },
                RV32IInstruction::JAL(_rd, imm) => {
                    // JAL指令：保存返回地址并跳转
                    ex_mem.alu_result = Some(ex_mem.pc.wrapping_add(4)); // 返回地址是下一条指令
                    // 分支处理
                    self.branch_taken = true;
                    self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                },
                RV32IInstruction::JALR(_, _, imm) => {
                    // JALR指令：保存返回地址并基于寄存器跳转
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some(ex_mem.pc.wrapping_add(4)); // 返回地址是下一条指令
                        // 分支处理
                        self.branch_taken = true;
                        self.next_pc = ((*a + *imm) & !1) as u32; // 确保结果是偶数
                    }
                },
                RV32IInstruction::BEQ(_, _, imm) => {
                    // BEQ指令：如果rs1 == rs2，执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        if *a == *b {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::BNE(_, _, imm) => {
                    // BNE指令：如果rs1 != rs2，执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        if *a != *b {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::BLT(_, _, imm) => {
                    // BLT指令：如果rs1 < rs2，执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        if *a < *b {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::BGE(_, _, imm) => {
                    // BGE指令：如果rs1 >= rs2，执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        if *a >= *b {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::BLTU(_, _, imm) => {
                    // BLTU指令：如果rs1 < rs2（无符号），执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if (*a as u32) < (*b as u32) {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::BGEU(_, _, imm) => {
                    // BGEU指令：如果rs1 >= rs2（无符号），执行分支
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if (*a as u32) >= (*b as u32) {
                            self.branch_taken = true;
                            self.next_pc = ex_mem.pc.wrapping_add(*imm as u32);
                        }
                    }
                },
                RV32IInstruction::MV(_, _) => {
                    // MV指令：直接在ID阶段处理，EX阶段不需要做任何事情
                },
                RV32IInstruction::LI(_, _) => {
                    // LI指令：直接在WB阶段处理，EX阶段不需要做任何事情
                },
                _ => {}
            }
        }
        
        // 5. 执行MEM阶段 (访存)
        // 使用当前计算出的EX/MEM寄存器状态
        let mut mem_wb = PipelineRegister::new();
        if let Some(instruction) = &ex_mem.instruction {
            mem_wb.instruction = Some(instruction.clone());
            mem_wb.pc = ex_mem.pc;
            mem_wb.alu_result = ex_mem.alu_result;
            mem_wb.rs1_value = ex_mem.rs1_value.clone();
            mem_wb.rs2_value = ex_mem.rs2_value.clone();
            mem_wb.memory_data = ex_mem.memory_data.clone();

            // 执行内存读写操作
            match instruction {
                RV32IInstruction::LW(_, _, _) => {
                    // 从内存读取一个字
                    if let Some(address) = ex_mem.alu_result {
                        let index = (address / 4) as usize;
                        if index < self.memory.len() {
                            mem_wb.memory_data = Some(self.memory[index].clone());
                        }
                    }
                },
                RV32IInstruction::LH(_, _, _) => {
                    // 从内存读取一个半字
                    if let Some(address) = ex_mem.alu_result {
                        let index = (address / 2) as usize;
                        if index < self.memory.len() {
                            // 简化处理，实际应考虑字节序和边界
                            mem_wb.memory_data = Some(self.memory[index].clone());
                        }
                    }
                },
                RV32IInstruction::LB(_, _, _) => {
                    // 从内存读取一个字节
                    if let Some(address) = ex_mem.alu_result {
                        let index = address as usize;
                        if index < self.memory.len() {
                            // 简化处理，实际应考虑字节序和边界
                            mem_wb.memory_data = Some(self.memory[index].clone());
                        }
                    }
                },
                RV32IInstruction::SW(_, _, _) => {
                    // 向内存写入一个字
                    if let (Some(address), Some(Value::Integer(value))) = 
                        (ex_mem.alu_result, &ex_mem.rs2_value) {
                        let index = (address / 4) as usize;
                        // 确保内存足够大
                        while self.memory.len() <= index {
                            self.memory.push(Value::Integer(0));
                        }
                        self.memory[index] = Value::Integer(*value);
                    }
                },
                RV32IInstruction::SH(_, _, _) => {
                    // 向内存写入一个半字
                    if let (Some(address), Some(Value::Integer(value))) = 
                        (ex_mem.alu_result, &ex_mem.rs2_value) {
                        let index = (address / 2) as usize;
                        // 确保内存足够大
                        while self.memory.len() <= index {
                            self.memory.push(Value::Integer(0));
                        }
                        // 简化处理，实际应考虑字节序和边界
                        self.memory[index] = Value::Integer(*value);
                    }
                },
                RV32IInstruction::SB(_, _, _) => {
                    // 向内存写入一个字节
                    if let (Some(address), Some(Value::Integer(value))) = 
                        (ex_mem.alu_result, &ex_mem.rs2_value) {
                        let index = address as usize;
                        // 确保内存足够大
                        while self.memory.len() <= index {
                            self.memory.push(Value::Integer(0));
                        }
                        // 简化处理，实际应考虑字节序和边界
                        self.memory[index] = Value::Integer(*value);
                    }
                },
                _ => {}
            }
        }
        
        // 6. 执行WB阶段 (写回)
        // 使用当前计算出的MEM/WB寄存器状态
        if let Some(instruction) = &mem_wb.instruction {
            match instruction {
                RV32IInstruction::ADD(rd, _, _) |
                RV32IInstruction::SUB(rd, _, _) |
                RV32IInstruction::AND(rd, _, _) |
                RV32IInstruction::OR(rd, _, _) |
                RV32IInstruction::XOR(rd, _, _) |
                RV32IInstruction::SLL(rd, _, _) |
                RV32IInstruction::SRL(rd, _, _) |
                RV32IInstruction::SRA(rd, _, _) |
                RV32IInstruction::SLT(rd, _, _) |
                RV32IInstruction::SLTU(rd, _, _) |
                RV32IInstruction::ADDI(rd, _, _) |
                RV32IInstruction::ANDI(rd, _, _) |
                RV32IInstruction::ORI(rd, _, _) |
                RV32IInstruction::XORI(rd, _, _) |
                RV32IInstruction::SLTI(rd, _, _) |
                RV32IInstruction::SLTIU(rd, _, _) |
                RV32IInstruction::SLLI(rd, _, _) |
                RV32IInstruction::SRLI(rd, _, _) |
                RV32IInstruction::SRAI(rd, _, _) |
                RV32IInstruction::JAL(rd, _) |
                RV32IInstruction::JALR(rd, _, _) |
                RV32IInstruction::LUI(rd, _) |
                RV32IInstruction::AUIPC(rd, _) => {
                    // 写回ALU结果
                    if let Some(result) = mem_wb.alu_result {
                        self.write_register(*rd, Value::Integer(result as i32));
                    }
                },
                
                RV32IInstruction::LW(rd, _, _) |
                RV32IInstruction::LH(rd, _, _) |
                RV32IInstruction::LB(rd, _, _) |
                RV32IInstruction::LHU(rd, _, _) |
                RV32IInstruction::LBU(rd, _, _) => {
                    // 写回内存加载结果
                    if let Some(value) = &mem_wb.memory_data {
                        self.write_register(*rd, value.clone());
                    }
                },
                
                RV32IInstruction::MV(rd, rs1) => {
                    // 寄存器移动
                    let value = self.read_register(*rs1).clone();
                    self.write_register(*rd, value);
                },
                
                RV32IInstruction::LI(rd, imm) => {
                    // 加载立即数
                    self.write_register(*rd, Value::Integer(*imm));
                },
                
                _ => {},
            }
        }
        
        // 7. 推进流水线寄存器
        self.pipeline_registers[1] = id_ex;
        self.pipeline_registers[2] = ex_mem;
        self.pipeline_registers[3] = mem_wb;
        
        // 打印流水线寄存器状态用于调试
        if self.verbose {
            println!("流水线寄存器状态:");
            println!("IF/ID: {:?}", self.pipeline_registers[0].instruction);
            println!("ID/EX: {:?}", self.pipeline_registers[1].instruction);
            println!("EX/MEM: {:?}", self.pipeline_registers[2].instruction);
            println!("MEM/WB: {:?}", self.pipeline_registers[3].instruction);
        }
        
        Ok(())
    }
    
    // IF阶段 (取指)
    fn fetch(&mut self) -> Result<()> {
        // 创建一个IF/ID阶段的新副本
        let mut if_id = PipelineRegister::new();
        
        // 从指令存储中获取指令
        // 注意：PC以字节为单位，需要除以4才能得到指令数组的索引
        let instruction_index = (self.pc / 4) as usize;
        let instruction = &self.instructions[instruction_index];
        
        // 设置IF/ID流水线寄存器
        if_id.instruction = Some(instruction.clone());
        if_id.pc = self.pc;
        
        // 将处理后的结果写回IF/ID阶段
        self.pipeline_registers[0] = if_id;
        
        Ok(())
    }
    
    // ID阶段 (译码)
    fn decode(&mut self) -> Result<()> {
        // 创建一个ID/EX阶段的新副本
        let mut id_ex = self.pipeline_registers[0].clone();
        
        // 解析指令，获取源寄存器值
        if let Some(ref instruction) = id_ex.instruction {
            match instruction {
                RV32IInstruction::SUB(_, rs1, rs2) |
                RV32IInstruction::AND(_, rs1, rs2) |
                RV32IInstruction::OR(_, rs1, rs2) |
                RV32IInstruction::XOR(_, rs1, rs2) |
                RV32IInstruction::SLL(_, rs1, rs2) |
                RV32IInstruction::SRL(_, rs1, rs2) |
                RV32IInstruction::SRA(_, rs1, rs2) |
                RV32IInstruction::SLT(_, rs1, rs2) |
                RV32IInstruction::SLTU(_, rs1, rs2) => {
                    // 读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone());
                },
                
                RV32IInstruction::LW(_rd, rs1, _) |
                RV32IInstruction::LH(_rd, rs1, _) |
                RV32IInstruction::LB(_rd, rs1, _) |
                RV32IInstruction::LHU(_rd, rs1, _) |
                RV32IInstruction::LBU(_rd, rs1, _) => {
                    // 加载指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::SW(rs2, rs1, _) |
                RV32IInstruction::SH(rs2, rs1, _) |
                RV32IInstruction::SB(rs2, rs1, _) => {
                    // 存储指令：读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone());
                },
                
                RV32IInstruction::ADDI(_rd, rs1, _) |
                RV32IInstruction::SLTI(_rd, rs1, _) |
                RV32IInstruction::SLTIU(_rd, rs1, _) |
                RV32IInstruction::XORI(_rd, rs1, _) |
                RV32IInstruction::ORI(_rd, rs1, _) |
                RV32IInstruction::ANDI(_rd, rs1, _) |
                RV32IInstruction::SLLI(_rd, rs1, _) |
                RV32IInstruction::SRLI(_rd, rs1, _) |
                RV32IInstruction::SRAI(_rd, rs1, _) => {
                    // 立即数指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::BEQ(rs1, rs2, _) |
                RV32IInstruction::BNE(rs1, rs2, _) |
                RV32IInstruction::BLT(rs1, rs2, _) |
                RV32IInstruction::BGE(rs1, rs2, _) |
                RV32IInstruction::BLTU(rs1, rs2, _) |
                RV32IInstruction::BGEU(rs1, rs2, _) => {
                    // 分支指令：读取rs1和rs2寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                    id_ex.rs2_value = Some(self.read_register(*rs2).clone());
                },
                
                RV32IInstruction::JAL(_, _) => {
                    // JAL指令不需要读取寄存器
                },
                
                RV32IInstruction::JALR(_, rs1, _) => {
                    // JALR指令：读取rs1寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                RV32IInstruction::LUI(_, _) |
                RV32IInstruction::AUIPC(_, _) => {
                    // LUI和AUIPC指令不需要读取寄存器
                },
                
                RV32IInstruction::MV(_rd, rs1) => {
                    // 寄存器移动：读取源寄存器值
                    id_ex.rs1_value = Some(self.read_register(*rs1).clone());
                },
                
                _ => {}
            }
        }
        
        // 将处理后的结果写回ID/EX阶段
        self.pipeline_registers[1] = id_ex;
        
        // 注意：不要清空IF/ID阶段，因为它在IF阶段执行时已经包含了新的指令
        
        Ok(())
    }
    
    // 检查数据冲突，返回是否需要暂停流水线
    fn check_data_hazards(&self, pipeline_registers: &[PipelineRegister; 4]) -> Result<bool> {
        // 对于五级流水线，我们需要检查所有可能的数据冲突情况
        // 检查ID阶段（pipeline_registers[0]）的指令是否需要读取的寄存器
        // 被后续阶段的指令写入
        if let Some(ref instruction_id) = pipeline_registers[0].instruction {
            // 确定当前指令的源寄存器
            let (rs1, rs2) = self.get_source_registers(instruction_id);
            
            // 检查EX阶段（pipeline_registers[1]）的目标寄存器
            if let Some(ref instruction_ex) = pipeline_registers[1].instruction {
                if let Some(rd_ex) = self.get_destination_register(instruction_ex) {
                    // 如果EX阶段写入的寄存器被ID阶段的指令读取，并且不是x0寄存器
                    if rd_ex != 0 && (rd_ex == rs1 || rs2 == Some(rd_ex)) {
                        // 特别处理加载指令，因为它们有额外的延迟
                        if let RV32IInstruction::LW(_, _, _) | 
                           RV32IInstruction::LH(_, _, _) | 
                           RV32IInstruction::LB(_, _, _) | 
                           RV32IInstruction::LHU(_, _, _) | 
                           RV32IInstruction::LBU(_, _, _) = instruction_ex {
                            // 加载指令引起的数据冲突，需要暂停流水线
                            return Ok(true);
                        }
                    }
                }
            }
            
            // 检查MEM阶段（pipeline_registers[2]）的目标寄存器
            if let Some(ref instruction_mem) = pipeline_registers[2].instruction {
                if let Some(rd_mem) = self.get_destination_register(instruction_mem) {
                    // 如果MEM阶段写入的寄存器被ID阶段的指令读取，并且不是x0寄存器
                    if rd_mem != 0 && (rd_mem == rs1 || rs2 == Some(rd_mem)) {
                        // 加载指令引起的数据冲突，需要暂停流水线
                        if let RV32IInstruction::LW(_, _, _) | 
                           RV32IInstruction::LH(_, _, _) | 
                           RV32IInstruction::LB(_, _, _) | 
                           RV32IInstruction::LHU(_, _, _) | 
                           RV32IInstruction::LBU(_, _, _) = instruction_mem {
                            return Ok(true);
                        }
                    }
                }
            }
        }
        
        // 没有检测到数据冲突
        Ok(false)
    }
    
    // 获取指令的源寄存器
    fn get_source_registers(&self, instruction: &RV32IInstruction) -> (u8, Option<u8>) {
        match instruction {
            RV32IInstruction::ADD(_, rs1, rs2) |
            RV32IInstruction::SUB(_, rs1, rs2) |
            RV32IInstruction::AND(_, rs1, rs2) |
            RV32IInstruction::OR(_, rs1, rs2) |
            RV32IInstruction::XOR(_, rs1, rs2) |
            RV32IInstruction::SLL(_, rs1, rs2) |
            RV32IInstruction::SRL(_, rs1, rs2) |
            RV32IInstruction::SRA(_, rs1, rs2) |
            RV32IInstruction::SLT(_, rs1, rs2) |
            RV32IInstruction::SLTU(_, rs1, rs2) => {
                (*rs1, Some(*rs2))
            },
            
            RV32IInstruction::LW(_, rs1, _) |
            RV32IInstruction::LH(_, rs1, _) |
            RV32IInstruction::LB(_, rs1, _) |
            RV32IInstruction::LHU(_, rs1, _) |
            RV32IInstruction::LBU(_, rs1, _) => {
                (*rs1, None)
            },
            
            RV32IInstruction::SW(_, rs1, _) |
            RV32IInstruction::SH(_, rs1, _) |
            RV32IInstruction::SB(_, rs1, _) => {
                (*rs1, None)
            },
            
            RV32IInstruction::ADDI(_, rs1, _) |
            RV32IInstruction::SLTI(_, rs1, _) |
            RV32IInstruction::SLTIU(_, rs1, _) |
            RV32IInstruction::XORI(_, rs1, _) |
            RV32IInstruction::ORI(_, rs1, _) |
            RV32IInstruction::ANDI(_, rs1, _) |
            RV32IInstruction::SLLI(_, rs1, _) |
            RV32IInstruction::SRLI(_, rs1, _) |
            RV32IInstruction::SRAI(_, rs1, _) => {
                (*rs1, None)
            },
            
            RV32IInstruction::BEQ(rs1, rs2, _) |
            RV32IInstruction::BNE(rs1, rs2, _) |
            RV32IInstruction::BLT(rs1, rs2, _) |
            RV32IInstruction::BGE(rs1, rs2, _) |
            RV32IInstruction::BLTU(rs1, rs2, _) |
            RV32IInstruction::BGEU(rs1, rs2, _) => {
                (*rs1, Some(*rs2))
            },
            
            RV32IInstruction::JAL(_, _) => {
                (0, None)
            },
            
            RV32IInstruction::JALR(_, rs1, _) => {
                (*rs1, None)
            },
            
            RV32IInstruction::LUI(_, _) |
            RV32IInstruction::AUIPC(_, _) => {
                (0, None)
            },
            
            RV32IInstruction::MV(_, rs1) => {
                (*rs1, None)
            },
            
            _ => {
                (0, None)
            }
        }
    }
    
    // 获取指令的目标寄存器
    fn get_destination_register(&self, instruction: &RV32IInstruction) -> Option<u8> {
        match instruction {
            RV32IInstruction::ADD(rd, _, _) => Some(*rd),
            RV32IInstruction::SUB(rd, _, _) => Some(*rd),
            RV32IInstruction::AND(rd, _, _) => Some(*rd),
            RV32IInstruction::OR(rd, _, _) => Some(*rd),
            RV32IInstruction::XOR(rd, _, _) => Some(*rd),
            RV32IInstruction::SLL(rd, _, _) => Some(*rd),
            RV32IInstruction::SRL(rd, _, _) => Some(*rd),
            RV32IInstruction::SRA(rd, _, _) => Some(*rd),
            RV32IInstruction::SLT(rd, _, _) => Some(*rd),
            RV32IInstruction::SLTU(rd, _, _) => Some(*rd),
            RV32IInstruction::LW(rd, _, _) => Some(*rd),
            RV32IInstruction::LH(rd, _, _) => Some(*rd),
            RV32IInstruction::LB(rd, _, _) => Some(*rd),
            RV32IInstruction::LHU(rd, _, _) => Some(*rd),
            RV32IInstruction::LBU(rd, _, _) => Some(*rd),
            RV32IInstruction::ADDI(rd, _, _) => Some(*rd),
            RV32IInstruction::SLTI(rd, _, _) => Some(*rd),
            RV32IInstruction::SLTIU(rd, _, _) => Some(*rd),
            RV32IInstruction::XORI(rd, _, _) => Some(*rd),
            RV32IInstruction::ORI(rd, _, _) => Some(*rd),
            RV32IInstruction::ANDI(rd, _, _) => Some(*rd),
            RV32IInstruction::SLLI(rd, _, _) => Some(*rd),
            RV32IInstruction::SRLI(rd, _, _) => Some(*rd),
            RV32IInstruction::SRAI(rd, _, _) => Some(*rd),
            RV32IInstruction::JAL(rd, _) => Some(*rd),
            RV32IInstruction::JALR(rd, _, _) => Some(*rd),
            RV32IInstruction::LUI(rd, _) => Some(*rd),
            RV32IInstruction::AUIPC(rd, _) => Some(*rd),
            RV32IInstruction::MV(rd, _) => Some(*rd),
            _ => None
        }
    }
    
    // EX阶段 (执行)
    fn execute(&mut self) -> Result<()> {
        // 创建一个EX/MEM阶段的新副本
        let mut ex_mem = self.pipeline_registers[1].clone();
        
        // 执行ALU操作
        if let Some(ref instruction) = ex_mem.instruction {
            match instruction {
                RV32IInstruction::ADD(_, _, _) => {
                    // 执行加法操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((*a + *b) as u32);
                    }
                },
                RV32IInstruction::ADDI(_, _, imm) => {
                    // 执行加立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a + *imm) as u32);
                    }
                },
                RV32IInstruction::SUB(_, _, _) => {
                    // 执行减法操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a - b) as u32);
                    }
                },
                RV32IInstruction::AND(_, _, _) => {
                    // 执行与操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a & b) as u32);
                    }
                },
                RV32IInstruction::ANDI(_, _, imm) => {
                    // 执行与立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a & *imm) as u32);
                    }
                },
                RV32IInstruction::OR(_, _, _) => {
                    // 执行或操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a | b) as u32);
                    }
                },
                RV32IInstruction::ORI(_, _, imm) => {
                    // 执行或立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a | *imm) as u32);
                    }
                },
                RV32IInstruction::XOR(_, _, _) => {
                    // 执行异或操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a ^ b) as u32);
                    }
                },
                RV32IInstruction::XORI(_, _, imm) => {
                    // 执行异或立即数操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a ^ *imm) as u32);
                    }
                },
                RV32IInstruction::SLL(_, _, _) => {
                    // 执行左移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a << (b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SLLI(_, _, shamt) => {
                    // 执行立即数左移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a << *shamt) as u32);
                    }
                },
                RV32IInstruction::SRL(_, _, _) => {
                    // 执行逻辑右移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {                        
                        ex_mem.alu_result = Some((*a as u32 >> (*b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRLI(_, _, shamt) => {
                    // 执行立即数逻辑右移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((*a as u32 >> *shamt) as u32);
                    }
                },
                RV32IInstruction::SRA(_, _, _) => {
                    // 执行算术右移操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some((a >> (b & 0x1F)) as u32);
                    }
                },
                RV32IInstruction::SRAI(_, _, shamt) => {
                    // 执行立即数算术右移操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((a >> *shamt) as u32);
                    }
                },
                RV32IInstruction::SLT(_, _, _) => {
                    // 执行有符号比较操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some(if a < b { 1 } else { 0 });
                    }
                },
                RV32IInstruction::SLTU(_, _, _) => {
                    // 执行无符号比较操作
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        ex_mem.alu_result = Some(if (*a as u32) < (*b as u32) { 1 } else { 0 });
                    }
                },
                RV32IInstruction::SLTI(_, _, imm) => {
                    // 执行有符号立即数比较操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some(if a < imm { 1 } else { 0 });
                    }
                },
                RV32IInstruction::SLTIU(_, _, imm) => {
                    // 执行无符号立即数比较操作
                    if let Some(Value::Integer(a)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some(if (*a as u32) < (*imm as u32) { 1 } else { 0 });
                    }
                },
                RV32IInstruction::BEQ(_, _, imm) => {
                    // 分支相等判断
                    if let (Some(a), Some(b)) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if a == b {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::BNE(_, _, imm) => {
                    // 分支不相等判断
                    if let (Some(a), Some(b)) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if a != b {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::BLT(_, _, imm) => {
                    // 分支小于判断
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if a < b {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::BGE(_, _, imm) => {
                    // 分支大于等于判断
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if a >= b {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::BLTU(_, _, imm) => {
                    // 无符号分支小于判断
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if (*a as u32) < (*b as u32) {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::BGEU(_, _, imm) => {
                    // 无符号分支大于等于判断
                    if let (Some(Value::Integer(a)), Some(Value::Integer(b))) = 
                        (&ex_mem.rs1_value, &ex_mem.rs2_value) {
                        if (*a as u32) >= (*b as u32) {
                            self.branch_taken = true;
                            self.next_pc = (ex_mem.pc as i32 + *imm) as u32;
                        }
                    }
                },
                RV32IInstruction::LW(_, _, imm) |
                RV32IInstruction::LH(_, _, imm) |
                RV32IInstruction::LB(_, _, imm) |
                RV32IInstruction::LHU(_, _, imm) |
                RV32IInstruction::LBU(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(addr)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((addr + *imm) as u32);
                    }
                },
                RV32IInstruction::SW(_, _, imm) |
                RV32IInstruction::SH(_, _, imm) |
                RV32IInstruction::SB(_, _, imm) => {
                    // 计算内存地址
                    if let Some(Value::Integer(addr)) = &ex_mem.rs1_value {
                        ex_mem.alu_result = Some((addr + *imm) as u32);
                    }
                },
                RV32IInstruction::JAL(_rd, imm) => {
                    // 计算跳转目标地址
                    let pc_val = ex_mem.pc;
                    self.next_pc = (pc_val as i32 + *imm) as u32;
                    self.branch_taken = true;
                    
                    // 计算返回地址并存储在流水线寄存器中供WB阶段使用
                    ex_mem.alu_result = Some(pc_val + 4);
                },
                RV32IInstruction::JALR(_rd, _, imm) => {
                    // 计算跳转目标地址
                    if let Some(Value::Integer(addr)) = &ex_mem.rs1_value {
                        self.next_pc = ((addr + *imm) & !1) as u32; // 确保目标地址是偶数
                        self.branch_taken = true;
                        
                        // 计算返回地址并存储在流水线寄存器中供WB阶段使用
                        ex_mem.alu_result = Some(ex_mem.pc + 4);
                    }
                },
                RV32IInstruction::LUI(_rd, imm) => {
                    // 加载高位立即数
                    ex_mem.alu_result = Some(((*imm as i32) << 12) as u32);
                },
                RV32IInstruction::AUIPC(_rd, imm) => {
                    // 加载高位立即数到PC
                    let pc_val = ex_mem.pc;
                    ex_mem.alu_result = Some((pc_val as i32 + ((*imm as i32) << 12)) as u32);
                },
                RV32IInstruction::MV(_, _) => {
                    // 寄存器移动操作
                    if let Some(value) = &ex_mem.rs1_value {
                        ex_mem.alu_result = match value {
                            Value::Integer(i) => Some(*i as u32),
                            _ => None
                        };
                    }
                },
                RV32IInstruction::NOP => {
                    // 空操作
                },
                _ => {
                    // 对于未实现的指令，给出警告
                    if self.verbose {
                        println!("Warning: Unsupported instruction in execute stage: {:?}", instruction);
                    }
                }
            }
        }
        
        // 将处理后的结果写回EX/MEM阶段
        self.pipeline_registers[2] = ex_mem;
        
        // 不需要清空ID/EX阶段，因为decode方法会覆盖它
        
        Ok(())
    }
    
    // MEM阶段 (访存)
    fn memory_access(&mut self) -> Result<()> {
        // 创建一个MEM/WB阶段的新副本
        let mut mem_wb = self.pipeline_registers[2].clone();
        
        // 访存操作
        if let Some(ref instruction) = mem_wb.instruction {
            match instruction {
                RV32IInstruction::LW(_, _, _) => {
                    // 加载字操作
                    if let Some(addr) = mem_wb.alu_result {
                        if let Ok(value) = self.read_memory(addr) {
                            mem_wb.memory_data = Some(value.clone());
                        }
                    }
                },
                RV32IInstruction::LH(_, _, _) => {
                    // 加载半字操作
                    if let Some(addr) = mem_wb.alu_result {
                        // 简化实现，与LW相同
                        if let Ok(value) = self.read_memory(addr) {
                            mem_wb.memory_data = Some(value.clone());
                        }
                    }
                },
                RV32IInstruction::LB(_, _, _) => {
                    // 加载字节操作
                    if let Some(addr) = mem_wb.alu_result {
                        // 简化实现，与LW相同
                        if let Ok(value) = self.read_memory(addr) {
                            mem_wb.memory_data = Some(value.clone());
                        }
                    }
                },
                RV32IInstruction::LHU(_, _, _) => {
                    // 无符号加载半字操作
                    if let Some(addr) = mem_wb.alu_result {
                        // 简化实现，与LW相同
                        if let Ok(value) = self.read_memory(addr) {
                            mem_wb.memory_data = Some(value.clone());
                        }
                    }
                },
                RV32IInstruction::LBU(_, _, _) => {
                    // 无符号加载字节操作
                    if let Some(addr) = mem_wb.alu_result {
                        // 简化实现，与LW相同
                        if let Ok(value) = self.read_memory(addr) {
                            mem_wb.memory_data = Some(value.clone());
                        }
                    }
                },
                RV32IInstruction::SW(_, _, _) => {
                    // 存储字操作
                    if let (Some(addr), Some(value)) = 
                        (mem_wb.alu_result, &mem_wb.rs2_value) {
                        self.write_memory(addr, value.clone())?;
                    }
                },
                RV32IInstruction::SH(_, _, _) => {
                    // 存储半字操作
                    if let (Some(addr), Some(value)) = 
                        (mem_wb.alu_result, &mem_wb.rs2_value) {
                        // 简化实现，与SW相同
                        self.write_memory(addr, value.clone())?;
                    }
                },
                RV32IInstruction::SB(_, _, _) => {
                    // 存储字节操作
                    if let (Some(addr), Some(value)) = 
                        (mem_wb.alu_result, &mem_wb.rs2_value) {
                        // 简化实现，与SW相同
                        self.write_memory(addr, value.clone())?;
                    }
                },
                RV32IInstruction::FENCE => {
                    // 内存屏障，简化实现
                },
                RV32IInstruction::FENCEI => {
                    // 指令屏障，简化实现
                },
                _ => {}
            }
        }
        
        // 将处理后的结果写回MEM/WB阶段
        self.pipeline_registers[3] = mem_wb;
        
        // 不需要清空EX/MEM阶段，因为它会在下一个时钟周期被覆盖
        
        Ok(())
    }
    
    // WB阶段 (写回)
    fn writeback(&mut self) -> Result<()> {
        // 创建一个本地副本用于操作
        let mem_wb = self.pipeline_registers[3].clone();
        
        // 写回操作
        if let Some(ref instruction) = mem_wb.instruction {
            match instruction {
                RV32IInstruction::ADD(rd, _, _) |
                RV32IInstruction::SUB(rd, _, _) |
                RV32IInstruction::AND(rd, _, _) |
                RV32IInstruction::OR(rd, _, _) |
                RV32IInstruction::XOR(rd, _, _) |
                RV32IInstruction::SLL(rd, _, _) |
                RV32IInstruction::SRL(rd, _, _) |
                RV32IInstruction::SRA(rd, _, _) |
                RV32IInstruction::SLT(rd, _, _) |
                RV32IInstruction::SLTU(rd, _, _) => {
                    // 写回ALU结果
                    if let Some(result) = mem_wb.alu_result {
                        self.write_register(*rd, Value::Integer(result as i32));
                    }
                },
                RV32IInstruction::ADDI(rd, _, _) |
                RV32IInstruction::ANDI(rd, _, _) |
                RV32IInstruction::ORI(rd, _, _) |
                RV32IInstruction::XORI(rd, _, _) |
                RV32IInstruction::SLTI(rd, _, _) |
                RV32IInstruction::SLTIU(rd, _, _) |
                RV32IInstruction::SLLI(rd, _, _) |
                RV32IInstruction::SRLI(rd, _, _) |
                RV32IInstruction::SRAI(rd, _, _) => {
                    // 写回ALU结果
                    if let Some(result) = mem_wb.alu_result {
                        self.write_register(*rd, Value::Integer(result as i32));
                    }
                },
                
                RV32IInstruction::LW(rd, _, _) |
                RV32IInstruction::LH(rd, _, _) |
                RV32IInstruction::LB(rd, _, _) |
                RV32IInstruction::LHU(rd, _, _) |
                RV32IInstruction::LBU(rd, _, _) => {
                    // 写回内存加载结果
                    if let Some(value) = &mem_wb.memory_data {
                        self.write_register(*rd, value.clone());
                    }
                },
                
                RV32IInstruction::JAL(rd, _) |
                RV32IInstruction::JALR(rd, _, _) => {
                    // 写回返回地址
                    if let Some(result) = mem_wb.alu_result {
                        self.write_register(*rd, Value::Integer(result as i32));
                    }
                },
                
                RV32IInstruction::LUI(rd, _) |
                RV32IInstruction::AUIPC(rd, _) => {
                    // 写回立即数结果
                    if let Some(result) = mem_wb.alu_result {
                        self.write_register(*rd, Value::Integer(result as i32));
                    }
                },
                
                RV32IInstruction::MV(rd, rs1) => {
                    // 寄存器移动
                    let value = self.read_register(*rs1).clone();
                    self.write_register(*rd, value);
                },
                
                RV32IInstruction::PrintReg(rs1) => {
                    // 打印寄存器值
                    let value = self.read_register(*rs1);
                    match value {
                        Value::Integer(i) => if self.verbose { println!("{}", i) },
                        Value::Float(f) => if self.verbose { println!("{}", f) },
                        Value::Boolean(b) => if self.verbose { println!("{}", b) },
                        Value::String(s) => if self.verbose { println!("{}", s) },
                        _ => if self.verbose { println!("{:?}", value) },
                    }
                },
                
                RV32IInstruction::TimerStart => {
                    // 启动计时器（简化实现）
                },
                
                RV32IInstruction::TimerStop => {
                    // 停止计时器（简化实现）
                },
                
                RV32IInstruction::TimerRead(rd) => {
                    // 读取计时器值（简化实现）
                    self.write_register(*rd, Value::Integer(0));
                },
                
                _ => {}
            }
        }
        
        // 不需要清空MEM/WB阶段，因为它会在下一个时钟周期被覆盖
        
        Ok(())
    }
    
    // 执行所有指令直到完成
    pub fn execute_all(&mut self) -> Result<()> {
        let instruction_count = self.instructions.len();
        
        // 首先执行直到PC达到指令数量
        while (self.pc as usize) < instruction_count {
            self.execute_pipeline()?;
        }
        
        // 额外执行多个周期，确保流水线中的所有指令都完成
        // 五级流水线，每条指令需要5个周期才能完全通过流水线
        // 为了保险起见，我们执行15个额外周期
        for _ in 0..15 {
            self.execute_pipeline()?;
        }
        Ok(())
    }
    
    // 简单执行模式 - 不使用流水线，直接按顺序执行每条指令
    // 用于调试和确保计算正确性
    pub fn execute_simple(&mut self) -> Result<()> {
        let instruction_count = self.instructions.len();
        
        // 重置PC到开始位置
        self.pc = 0;
        
        // 使用while循环代替for循环，完全依赖PC来控制执行流程
        while (self.pc as usize / 4) < instruction_count {
            // 获取当前指令索引
            let current_index = self.pc as usize / 4;
            
            // 获取当前指令
            let instruction = self.instructions[current_index].clone(); // 复制指令，避免借用冲突
            
            // 默认下一条指令是当前指令的下一条
            let mut next_pc = self.pc.wrapping_add(4);
            
            // 简单执行每条指令
            match instruction {
                RV32IInstruction::ADD(rd, rs1, rs2) => {
                    // 执行加法操作
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        self.write_register(rd, Value::Integer(a_val + b_val));
                    }
                },
                RV32IInstruction::ADDI(rd, rs1, imm) => {
                    // 执行加立即数操作
                    let a = self.read_register(rs1).clone();
                    if let Value::Integer(a_val) = a {
                        self.write_register(rd, Value::Integer(a_val + imm));
                    }
                },
                RV32IInstruction::SUB(rd, rs1, rs2) => {
                    // 执行减法操作
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        self.write_register(rd, Value::Integer(a_val - b_val));
                    }
                },
                RV32IInstruction::BEQ(rs1, rs2, imm) => {
                    // BEQ指令：如果rs1 == rs2，执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        if a_val == b_val {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::BNE(rs1, rs2, imm) => {
                    // BNE指令：如果rs1 != rs2，执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        if a_val != b_val {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::BLT(rs1, rs2, imm) => {
                    // BLT指令：如果rs1 < rs2，执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        if a_val < b_val {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::MV(rd, rs1) => {
                    // 寄存器移动
                    let value = self.read_register(rs1).clone();
                    self.write_register(rd, value);
                },
                RV32IInstruction::JAL(rd, imm) => {
                    // 跳转到目标位置，并保存返回地址
                    let return_address = self.pc.wrapping_add(4);
                    self.write_register(rd, Value::Integer(return_address as i32));
                    next_pc = self.pc.wrapping_add(imm as u32);
                },
                RV32IInstruction::JALR(rd, rs1, imm) => {
                    // 跳转到寄存器指定的位置加偏移量
                    let base = self.read_register(rs1).clone();
                    if let Value::Integer(base_val) = base {
                        // 保存返回地址
                        let return_address = self.pc.wrapping_add(4);
                        self.write_register(rd, Value::Integer(return_address as i32));
                        
                        // 计算目标地址并确保它是偶数
                        let target_address = (base_val + imm) as u32 & !1;
                        next_pc = target_address;
                    }
                },
                RV32IInstruction::LI(rd, imm) => {
                    // 加载立即数操作
                    self.write_register(rd, Value::Integer(imm));
                },
                RV32IInstruction::BGE(rs1, rs2, imm) => {
                    // BGE指令：如果rs1 >= rs2，执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        if a_val >= b_val {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::BGEU(rs1, rs2, imm) => {
                    // BGEU指令：如果rs1 >= rs2（无符号），执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        let a_uint = a_val.unsigned_abs();
                        let b_uint = b_val.unsigned_abs();
                        if a_uint >= b_uint {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::BLTU(rs1, rs2, imm) => {
                    // BLTU指令：如果rs1 < rs2（无符号），执行分支
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        let a_uint = a_val.unsigned_abs();
                        let b_uint = b_val.unsigned_abs();
                        if a_uint < b_uint {
                            // 跳转到目标位置
                            next_pc = self.pc.wrapping_add(imm as u32);
                        }
                    }
                },
                RV32IInstruction::NOP => {
                    // 空操作，不做任何事情
                },
                RV32IInstruction::HALT => {
                    // 停机指令，提前结束执行
                    self.pc = (instruction_count * 4) as u32;
                },
                RV32IInstruction::AND(rd, rs1, rs2) => {
                    // 按位与操作
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        self.write_register(rd, Value::Integer(a_val & b_val));
                    }
                },
                RV32IInstruction::OR(rd, rs1, rs2) => {
                    // 按位或操作
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        self.write_register(rd, Value::Integer(a_val | b_val));
                    }
                },
                RV32IInstruction::XOR(rd, rs1, rs2) => {
                    // 按位异或操作
                    let a = self.read_register(rs1).clone();
                    let b = self.read_register(rs2).clone();
                    if let (Value::Integer(a_val), Value::Integer(b_val)) = (a, b) {
                        self.write_register(rd, Value::Integer(a_val ^ b_val));
                    }
                },
                // 其他未实现的指令
                _ => {
                    // 对于未实现的指令，我们可以选择忽略它们或执行一个默认操作
                }
            }
            
            // 更新PC到下一条指令或跳转目标
            self.pc = next_pc;
        }
        
        Ok(())
    }
    
    // 打印寄存器状态
    pub fn print_registers(&self) {
        if self.verbose {
            println!("Registers:");
        for i in 0..32 {
            if let Value::Integer(val) = self.read_register(i as u8) {
                if self.verbose { println!("x{}: {}", i, val); }
            }
        }
            println!("PC: {}", self.pc);
        }
    }
    
    // 打印栈状态
    pub fn print_stack(&self) {
        if self.verbose {
            println!("Stack (top to bottom):");
        for (i, value) in self.stack.iter().enumerate().rev() {
            if self.verbose { println!("  [{}]: {:?}", i, value); }
        }
        }
    }
}